package model

import (
	"log"
)

type Order struct {
	BaseModel
	TradeId       string `json:"trade_id"`
	TransactionId string `json:"transaction_id"`
	ProductId     int    `json:"product_id"`
	BuyerOpenId   string `json:"buyer_open_id"`
	SellerOpenId  string `json:"seller_open_id"`
	Amount        string `json:"amount"`
	Address       string `json:"address"`
	Status        int    `json:"status"`
}
type OrderProductInfo struct {
	Order   Order
	Product ProductModel
}

func CreateOrderFactory(sqlType string) *Order {
	return &Order{BaseModel: BaseModel{DB: UseDbConn(sqlType)}}
}

func (Order) TableName() string {
	return "tb_order"
}

// 处理支付成功的回调逻辑
func (o *Order) PaySuccess(tradeId, buyerOpenId string) {
	// Step 1: 查询订单
	if err := o.DB.Where("trade_id = ? AND buyer_open_id = ?", tradeId, buyerOpenId).First(o).Error; err != nil {
		log.Printf("查询订单失败: %v", err)
		return
	}

	// Step 2: 更新订单状态为 1（已支付）
	if err := o.DB.Model(o).Update("status", 1).Error; err != nil {
		log.Printf("更新订单状态失败: %v", err)
		return
	}

	// Step 3: 使用查出的 ProductId 更新商品状态为 2（已出售）
	if err := o.DB.Model(&ProductModel{}).Where("id = ?", o.ProductId).Update("status", 2).Error; err != nil {
		log.Printf("更新商品状态失败: %v", err)
		return
	}
}

// 创建订单
// 修改 model/order_model.go 中的 CreateOrder 方法
func (o *Order) CreateOrder(productId int, buyerOpenId, sellerOpenId, address, amount, orderNo string) *Order {
	o.TradeId = orderNo
	o.ProductId = productId
	o.BuyerOpenId = buyerOpenId
	o.SellerOpenId = sellerOpenId
	o.Amount = amount
	o.Address = address
	o.Status = 0
	if err := o.DB.Create(o).Error; err != nil {
		log.Printf("创建订单失败: %v", err)
		return nil
	}
	return o // 返回当前订单对象
}

func (o *Order) GetOrderByProductIdAndBuyerOpenId(id int, id2 string) ([]Order, error) {
	var orders []Order
	db := o.DB.Where("product_id = ? AND buyer_open_id = ?", id, id2).Find(&orders)
	if db.Error != nil {
		return nil, db.Error
	}
	return orders, nil
}

func (o Order) UpdateTransactionId(id string, id2 string) {
	if err := o.DB.Model(&Order{}).Where("trade_id = ?", id).Update("transaction_id", id2).Error; err != nil {
		log.Printf("更新订单状态失败: %v", err)
		return
	}
}

/*func (o Order) GetProductInfo(tradeId string) interface{} {
	// Step 1: 根据 tradeId 查询订单
	var order Order
	if err := o.DB.Where("trade_id = ?", tradeId).First(&order).Error; err != nil {
		log.Printf("查询订单失败: %v", err)
		return nil
	}

	// Step 2: 根据 ProductId 查询商品信息
	var product ProductModel
	if err := o.DB.Where("id = ?", order.ProductId).First(&product).Error; err != nil {
		log.Printf("查询商品信息失败: %v", err)
		return nil
	}

	// Step 3: 返回商品信息
	return product
}
*/

func (o Order) GetProductInfo(tradeId string) interface{} {
	// Step 1: 根据 tradeId 查询订单
	var order Order
	if err := o.DB.Where("trade_id = ?", tradeId).First(&order).Error; err != nil {
		log.Printf("查询订单失败: %v", err)
		return nil
	}

	// Step 2: 根据 ProductId 查询商品信息
	var product ProductModel
	if err := o.DB.Where("id = ?", order.ProductId).First(&product).Error; err != nil {
		log.Printf("查询商品信息失败: %v", err)
		return nil
	}

	// Step 3: 返回订单和商品信息
	return OrderProductInfo{
		Order:   order,
		Product: product,
	}
}

/*func (o Order) QueryOrders(id string) ([]map[string]interface{}, error) {
	var orders []Order
	var result []map[string]interface{}

	// Step 1: 根据 buyer_open_id 查询订单列表
	if err := o.DB.Where("buyer_open_id = ?", id).Find(&orders).Error; err != nil {
		return nil, err
	}

	// Step 2: 遍历每个订单，查询对应的商品信息，并组合返回
	for _, order := range orders {
		var product ProductModel
		if err := o.DB.Where("id = ?", order.ProductId).First(&product).Error; err != nil {
			return nil, err
		}

		// 将订单和商品信息组合成 map 返回
		result = append(result, map[string]interface{}{
			"order":   order,
			"product": product,
		})
	}

	return result, nil
}*/

func (o Order) QueryOrders(id string) ([]map[string]interface{}, error) {
	var orders []Order
	var result []map[string]interface{}

	// Step 1: 根据 buyer_open_id 查询订单列表
	if err := o.DB.Where("buyer_open_id = ?", id).Find(&orders).Error; err != nil {
		return nil, err
	}

	// Step 2: 遍历每个订单，查询对应的商品信息和 review 信息，并组合返回
	for _, order := range orders {
		var product ProductModel
		if err := o.DB.Where("id = ?", order.ProductId).First(&product).Error; err != nil {
			return nil, err
		}

		// Step 3: 查询 review 数据，条件是 reviewer_open_id = id 且 OrderId 与当前订单匹配
		var review ReviewModel
		db := o.DB.Where("order_id = ? AND reviewer_open_id = ?", order.Id, id).First(&review)
		if db.Error != nil {
			// 如果没有找到 review 记录，可以跳过或选择返回空值
			// 这里选择继续处理并返回空 review 字段
		}

		// 将订单、商品信息和 review 组合成 map 返回
		result = append(result, map[string]interface{}{
			"order":   order,
			"product": product,
			"review":  review,
		})
	}

	return result, nil
}

func (o Order) UpdatePrice(id string, price string) {
	//根据商品id修改价格
	if err := o.DB.Model(&Order{}).Where("product_id = ?", id).Update("amount", price).Error; err != nil {
		log.Printf("更新订单状态失败: %v", err)
		return
	}
}

func (o Order) GetOrderAmountByTradeId(tradeId string) string {
	var amount string
	if err := o.DB.Model(&Order{}).Where("trade_id = ?", tradeId).Pluck("amount", &amount).Error; err != nil {
		log.Printf("查询订单金额失败: %v", err)
		return ""
	}
	return amount
}

func (o Order) CancelOrder(trade_id string) error {
	//根据trade_id去删除相关的订单
	if err := o.DB.Where("trade_id = ?", trade_id).Delete(&Order{}).Error; err != nil {
		log.Printf("删除订单失败: %v", err)
		return err
	}
	return nil
}
